package com.estore.service;

import com.estore.model.Product;
import java.io.*;
import java.nio.file.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 商品业务层：统一管理商品数据和排序逻辑，对外提供业务接口
 */
public class ProductService {
    // 内存Map模拟数据库：key=商品ID，value=商品对象
    private final Map<String, Product> productDB = new HashMap<>();
    private String DATA_FILE_PATH;
    private String BACKUP_DIR;
    // 构造器：初始化商品数据（含标签）
    public ProductService() {
        loadConfig();
        loadData();
        if (productDB.isEmpty()) {
            initializeDefaultData();
            saveData(); // 初始数据保存并触发备份
        }
    }

    /**
     * 加载配置文件
     */
    private void loadConfig() {
        Properties prop = new Properties();
        try (InputStream input = getClass().getClassLoader().getResourceAsStream("config.properties")) {
            if (input == null) {
                System.err.println("⚠️ config.properties 文件未找到，使用默认路径。");
                DATA_FILE_PATH = "data/products.dat";
                BACKUP_DIR = "data/backup";
                return;
            }
            prop.load(input);
            DATA_FILE_PATH = prop.getProperty("data.file.path", "data/products.dat");
            BACKUP_DIR = prop.getProperty("backup.dir", "data/backup");
        } catch (IOException ex) {
            System.err.println("❌ 加载配置失败，使用默认路径：" + ex.getMessage());
            DATA_FILE_PATH = "data/products.dat";
            BACKUP_DIR = "data/backup";
        }
    }
    /**
     * 从文件加载商品数据
     */
    private void loadData() {
        File file = new File(DATA_FILE_PATH);
        if (!file.exists()) {
            System.out.println("数据文件不存在，将创建新文件。");
            return;
        }
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {
            @SuppressWarnings("unchecked")
            Map<String, Product> loaded = (Map<String, Product>) ois.readObject();
            productDB.clear();
            productDB.putAll(loaded);
            System.out.println("✅ 商品数据加载成功，共 " + productDB.size() + " 条记录。");
        } catch (IOException | ClassNotFoundException e) {
            System.err.println("❌ 加载商品数据失败：" + e.getMessage());
            e.printStackTrace();
        }
    }
    /**
     * 保存商品数据到文件
     */
    public void saveData() {
        File dir = new File(DATA_FILE_PATH).getParentFile();
        if (dir != null && !dir.exists() && !dir.mkdirs()) {
            System.err.println("❌ 无法创建数据目录：" + dir.getAbsolutePath());
            return;
        }
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(DATA_FILE_PATH))) {
            oos.writeObject(productDB);
            System.out.println("✅ 商品数据已保存到 " + DATA_FILE_PATH);
            backupData(); // 保存后立即备份
        } catch (IOException e) {
            System.err.println("❌ 保存商品数据失败：" + e.getMessage());
            e.printStackTrace();
        }
    }
    /**
     * 备份数据文件
     */
    public void backupData() {
        File dataFile = new File(DATA_FILE_PATH);
        if (!dataFile.exists()) {
            System.out.println("⚠️ 当前无数据文件，跳过备份。");
            return;
        }
        File backupDir = new File(BACKUP_DIR);
        if (!backupDir.exists() && !backupDir.mkdirs()) {
            System.err.println("❌ 无法创建备份目录：" + BACKUP_DIR);
            return;
        }
        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
        String backupFileName = "products_" + timestamp + ".bak";
        Path backupPath = Paths.get(BACKUP_DIR, backupFileName);

        try {
            Files.copy(dataFile.toPath(), backupPath, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("✅ 数据已备份到：" + backupPath);
        } catch (IOException e) {
            System.err.println("❌ 备份失败：" + e.getMessage());
            e.printStackTrace();
        }
    }
    /**
     * 初始化默认商品数据
     */
    private void initializeDefaultData() {
        Set<String> tagsForJavaBook = new HashSet<>(Arrays.asList("编程", "畅销"));
        productDB.put("p001", new Product("p001", "Java从入门到精通", 99.0, 100, tagsForJavaBook));

        Set<String> tagsForMySQLBook = new HashSet<>(Arrays.asList("数据库", "进阶"));
        productDB.put("p002", new Product("p002", "高性能MySQL", 128.5, 50, tagsForMySQLBook));

        Set<String> tagsForNeckBook = new HashSet<>(Arrays.asList("热门", "健康"));
        productDB.put("p003", new Product("p003", "颈椎康复指南", 45.0, 200, tagsForNeckBook));

        productDB.put("p004", new Product("p004", "生发秘籍", 88.0, 0));
    }

    /**
     * 按指定规则获取排序后的商品列表
     * @param sortType 排序类型：1=ID升序，2=价格升序，3=价格降序，4=库存降序
     * @return 排序后的商品列表
     */
    public List<Product> getSortedProducts(int sortType) {
        List<Product> products = new ArrayList<>(productDB.values());

        // 根据排序类型选择比较器
        Comparator<Product> comparator = switch (sortType) {
            case 2 -> Comparator.comparingDouble(Product::getPrice); // 价格升序
            case 3 -> Comparator.comparingDouble(Product::getPrice).reversed(); // 价格降序
            case 4 -> Comparator.comparingInt(Product::getStock).reversed(); // 库存降序
            default -> Comparator.comparing(Product::getId); // 默认：ID升序
        };

        products.sort(comparator);
        return products;
    }

    /**
     * 根据ID查询商品
     * @param productId 商品ID
     * @return 商品对象（不存在则返回null）
     */
    public Product getProductById(String productId) {
        return productDB.get(productId);
    }
}
